home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / binutils / binutils.info (.txt) < prev    next >
GNU Info File  |  1994-10-13  |  52KB  |  1,091 lines
  1. This is Info file binutils.info, produced by Makeinfo-1.55 from the
  2. input file ./binutils.texi.
  3. START-INFO-DIR-ENTRY
  4. * Binutils: (binutils).         The GNU binary utilities "ar", "objcopy",
  5.                 "objdump", "nm", "nlmconv", "size",
  6.                                 "strings", "strip", and "ranlib".
  7. END-INFO-DIR-ENTRY
  8.    Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
  9.    Permission is granted to make and distribute verbatim copies of this
  10. manual provided the copyright notice and this permission notice are
  11. preserved on all copies.
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.    Permission is granted to copy and distribute translations of this
  17. manual into another language, under the above conditions for modified
  18. versions.
  19. File: binutils.info,  Node: Top,  Next: ar,  Prev: (DIR),  Up: (DIR)
  20. Introduction
  21. ************
  22.    This brief manual contains preliminary documentation for the GNU
  23. binary utilities (collectively version 2.2):
  24. * Menu:
  25. * ar::                          Create, modify, and extract from archives
  26. * nm::                          List symbols from object files
  27. * objcopy::            Copy and translate object files
  28. * objdump::                     Display information from object files
  29. * ranlib::                      Generate index to archive contents
  30. * size::                        List section sizes and total size
  31. * strings::                     List printable strings from files
  32. * strip::                       Discard symbols
  33. * c++filt::            Filter to demangle encoded C++ symbols
  34. * nlmconv::                     Converts object code into an NLM
  35. * Selecting The Target System:: How these utilities determine the target.
  36. * Index::
  37. File: binutils.info,  Node: ar,  Next: nm,  Prev: Top,  Up: Top
  38.      ar [-]P[MOD [RELPOS]] ARCHIVE [MEMBER...]
  39.      ar -M [ <mri-script ]
  40.    The GNU `ar' program creates, modifies, and extracts from archives.
  41. An "archive" is a single file holding a collection of other files in a
  42. structure that makes it possible to retrieve the original individual
  43. files (called "members" of the archive).
  44.    The original files' contents, mode (permissions), timestamp, owner,
  45. and group are preserved in the archive, and can be restored on
  46. extraction.
  47.    GNU `ar' can maintain archives whose members have names of any
  48. length; however, depending on how `ar' is configured on your system, a
  49. limit on member-name length may be imposed for compatibility with
  50. archive formats maintained with other tools.  If it exists, the limit
  51. is often 15 characters (typical of formats related to a.out) or 16
  52. characters (typical of formats related to coff).
  53.    `ar' is considered a binary utility because archives of this sort
  54. are most often used as "libraries" holding commonly needed subroutines.
  55.    `ar' creates an index to the symbols defined in relocatable object
  56. modules in the archive when you specify the modifier `s'.  Once
  57. created, this index is updated in the archive whenever `ar' makes a
  58. change to its contents (save for the `q' update operation).  An archive
  59. with such an index speeds up linking to the library, and allows
  60. routines in the library to call each other without regard to their
  61. placement in the archive.
  62.    You may use `nm -s' or `nm --print-armap' to list this index table.
  63. If an archive lacks the table, another form of `ar' called `ranlib' can
  64. be used to add just the table.
  65.    GNU `ar' is designed to be compatible with two different facilities.
  66. You can control its activity using command-line options, like the
  67. different varieties of `ar' on Unix systems; or, if you specify the
  68. single command-line option `-M', you can control it with a script
  69. supplied via standard input, like the MRI "librarian" program.
  70. * Menu:
  71. * ar cmdline::                  Controlling `ar' on the command line
  72. * ar scripts::                  Controlling `ar' with a script
  73. File: binutils.info,  Node: ar cmdline,  Next: ar scripts,  Up: ar
  74. Controlling `ar' on the command line
  75. ====================================
  76.      ar [-]P[MOD [RELPOS]] ARCHIVE [MEMBER...]
  77.    When you use `ar' in the Unix style, `ar' insists on at least two
  78. arguments to execute: one keyletter specifying the *operation*
  79. (optionally accompanied by other keyletters specifying *modifiers*),
  80. and the archive name to act on.
  81.    Most operations can also accept further MEMBER arguments, specifying
  82. particular files to operate on.
  83.    GNU `ar' allows you to mix the operation code P and modifier flags
  84. MOD in any order, within the first command-line argument.
  85.    If you wish, you may begin the first command-line argument with a
  86. dash.
  87.    The P keyletter specifies what operation to execute; it may be any
  88. of the following, but you must specify only one of them:
  89.      *Delete* modules from the archive.  Specify the names of modules to
  90.      be deleted as MEMBER...; the archive is untouched if you specify
  91.      no files to delete.
  92.      If you specify the `v' modifier, `ar' lists each module as it is
  93.      deleted.
  94.      Use this operation to *move* members in an archive.
  95.      The ordering of members in an archive can make a difference in how
  96.      programs are linked using the library, if a symbol is defined in
  97.      more than one member.
  98.      If no modifiers are used with `m', any members you name in the
  99.      MEMBER arguments are moved to the *end* of the archive; you can
  100.      use the `a', `b', or `i' modifiers to move them to a specified
  101.      place instead.
  102.      *Print* the specified members of the archive, to the standard
  103.      output file.  If the `v' modifier is specified, show the member
  104.      name before copying its contents to standard output.
  105.      If you specify no MEMBER arguments, all the files in the archive
  106.      are printed.
  107.      *Quick append*; add the files MEMBER... to the end of ARCHIVE,
  108.      without checking for replacement.
  109.      The modifiers `a', `b', and `i' do *not* affect this operation;
  110.      new members are always placed at the end of the archive.
  111.      The modifier `v' makes `ar' list each file as it is appended.
  112.      Since the point of this operation is speed, the archive's symbol
  113.      table index is not updated, even if it already existed; you can
  114.      use `ar s' or `ranlib' explicitly to update the symbol table index.
  115.      Insert the files MEMBER... into ARCHIVE (with *replacement*). This
  116.      operation differs from `q' in that any previously existing members
  117.      are deleted if their names match those being added.
  118.      If one of the files named in MEMBER... does not exist, `ar'
  119.      displays an error message, and leaves undisturbed any existing
  120.      members of the archive matching that name.
  121.      By default, new members are added at the end of the file; but you
  122.      may use one of the modifiers `a', `b', or `i' to request placement
  123.      relative to some existing member.
  124.      The modifier `v' used with this operation elicits a line of output
  125.      for each file inserted, along with one of the letters `a' or `r'
  126.      to indicate whether the file was appended (no old member deleted)
  127.      or replaced.
  128.      Display a *table* listing the contents of ARCHIVE, or those of the
  129.      files listed in MEMBER... that are present in the archive.
  130.      Normally only the member name is shown; if you also want to see
  131.      the modes (permissions), timestamp, owner, group, and size, you can
  132.      request that by also specifying the `v' modifier.
  133.      If you do not specify a MEMBER, all files in the archive are
  134.      listed.
  135.      If there is more than one file with the same name (say, `fie') in
  136.      an archive (say `b.a'), `ar t b.a fie' lists only the first
  137.      instance; to see them all, you must ask for a complete listing--in
  138.      our example, `ar t b.a'.
  139.      *Extract* members (named MEMBER) from the archive.  You can use
  140.      the `v' modifier with this operation, to request that `ar' list
  141.      each name as it extracts it.
  142.      If you do not specify a MEMBER, all files in the archive are
  143.      extracted.
  144.    A number of modifiers (MOD) may immediately follow the P keyletter,
  145. to specify variations on an operation's behavior:
  146.      Add new files *after* an existing member of the archive.  If you
  147.      use the modifier `a', the name of an existing archive member must
  148.      be present as the RELPOS argument, before the ARCHIVE
  149.      specification.
  150.      Add new files *before* an existing member of the archive.  If you
  151.      use the modifier `b', the name of an existing archive member must
  152.      be present as the RELPOS argument, before the ARCHIVE
  153.      specification.  (same as `i').
  154.      *Create* the archive.  The specified ARCHIVE is always created if
  155.      it did not exist, when you request an update.  But a warning is
  156.      issued unless you specify in advance that you expect to create it,
  157.      by using this modifier.
  158.      Insert new files *before* an existing member of the archive.  If
  159.      you use the modifier `i', the name of an existing archive member
  160.      must be present as the RELPOS argument, before the ARCHIVE
  161.      specification.  (same as `b').
  162.      This modifier is accepted but not used.
  163.      Preserve the *original* dates of members when extracting them.  If
  164.      you do not specify this modifier, files extracted from the archive
  165.      are stamped with the time of extraction.
  166.      Write an object-file index into the archive, or update an existing
  167.      one, even if no other change is made to the archive.  You may use
  168.      this modifier flag either with any operation, or alone.  Running
  169.      `ar s' on an archive is equivalent to running `ranlib' on it.
  170.      Normally, `ar r'... inserts all files listed into the archive.  If
  171.      you would like to insert *only* those of the files you list that
  172.      are newer than existing members of the same names, use this
  173.      modifier.  The `u' modifier is allowed only for the operation `r'
  174.      (replace).  In particular, the combination `qu' is not allowed,
  175.      since checking the timestamps would lose any speed advantage from
  176.      the operation `q'.
  177.      This modifier requests the *verbose* version of an operation.  Many
  178.      operations display additional information, such as filenames
  179.      processed, when the modifier `v' is appended.
  180.      This modifier shows the version number of `ar'.
  181. File: binutils.info,  Node: ar scripts,  Prev: ar cmdline,  Up: ar
  182. Controlling `ar' with a script
  183. ==============================
  184.      ar -M [ <SCRIPT ]
  185.    If you use the single command-line option `-M' with `ar', you can
  186. control its operation with a rudimentary command language.  This form
  187. of `ar' operates interactively if standard input is coming directly
  188. from a terminal.  During interactive use, `ar' prompts for input (the
  189. prompt is `AR >'), and continues executing even after errors.  If you
  190. redirect standard input to a script file, no prompts are issued, and
  191. `ar' abandons execution (with a nonzero exit code) on any error.
  192.    The `ar' command language is *not* designed to be equivalent to the
  193. command-line options; in fact, it provides somewhat less control over
  194. archives.  The only purpose of the command language is to ease the
  195. transition to GNU `ar' for developers who already have scripts written
  196. for the MRI "librarian" program.
  197.    The syntax for the `ar' command language is straightforward:
  198.    * commands are recognized in upper or lower case; for example, `LIST'
  199.      is the same as `list'.  In the following descriptions, commands are
  200.      shown in upper case for clarity.
  201.    * a single command may appear on each line; it is the first word on
  202.      the line.
  203.    * empty lines are allowed, and have no effect.
  204.    * comments are allowed; text after either of the characters `*' or
  205.      `;' is ignored.
  206.    * Whenever you use a list of names as part of the argument to an `ar'
  207.      command, you can separate the individual names with either commas
  208.      or blanks.  Commas are shown in the explanations below, for
  209.      clarity.
  210.    * `+' is used as a line continuation character; if `+' appears at
  211.      the end of a line, the text on the following line is considered
  212.      part of the current command.
  213.    Here are the commands you can use in `ar' scripts, or when using
  214. `ar' interactively.  Three of them have special significance:
  215.    `OPEN' or `CREATE' specify a "current archive", which is a temporary
  216. file required for most of the other commands.
  217.    `SAVE' commits the changes so far specified by the script.  Prior to
  218. `SAVE', commands affect only the temporary copy of the current archive.
  219. `ADDLIB ARCHIVE'
  220. `ADDLIB ARCHIVE (MODULE, MODULE, ... MODULE)'
  221.      Add all the contents of ARCHIVE (or, if specified, each named
  222.      MODULE from ARCHIVE) to the current archive.
  223.      Requires prior use of `OPEN' or `CREATE'.
  224. `ADDMOD MEMBER, MEMBER, ... MEMBER'
  225.      Add each named MEMBER as a module in the current archive.
  226.      Requires prior use of `OPEN' or `CREATE'.
  227. `CLEAR'
  228.      Discard the contents of the current archive, cancelling the effect
  229.      of any operations since the last `SAVE'.  May be executed (with no
  230.      effect) even if  no current archive is specified.
  231. `CREATE ARCHIVE'
  232.      Creates an archive, and makes it the current archive (required for
  233.      many other commands).  The new archive is created with a temporary
  234.      name; it is not actually saved as ARCHIVE until you use `SAVE'.
  235.      You can overwrite existing archives; similarly, the contents of any
  236.      existing file named ARCHIVE will not be destroyed until `SAVE'.
  237. `DELETE MODULE, MODULE, ... MODULE'
  238.      Delete each listed MODULE from the current archive; equivalent to
  239.      `ar -d ARCHIVE MODULE ... MODULE'.
  240.      Requires prior use of `OPEN' or `CREATE'.
  241. `DIRECTORY ARCHIVE (MODULE, ... MODULE)'
  242. `DIRECTORY ARCHIVE (MODULE, ... MODULE) OUTPUTFILE'
  243.      List each named MODULE present in ARCHIVE.  The separate command
  244.      `VERBOSE' specifies the form of the output: when verbose output is
  245.      off, output is like that of `ar -t ARCHIVE MODULE...'.  When
  246.      verbose output is on, the listing is like `ar -tv ARCHIVE
  247.      MODULE...'.
  248.      Output normally goes to the standard output stream; however, if you
  249.      specify OUTPUTFILE as a final argument, `ar' directs the output to
  250.      that file.
  251. `END'
  252.      Exit from `ar', with a `0' exit code to indicate successful
  253.      completion.  This command does not save the output file; if you
  254.      have changed the current archive since the last `SAVE' command,
  255.      those changes are lost.
  256. `EXTRACT MODULE, MODULE, ... MODULE'
  257.      Extract each named MODULE from the current archive, writing them
  258.      into the current directory as separate files.  Equivalent to `ar -x
  259.      ARCHIVE MODULE...'.
  260.      Requires prior use of `OPEN' or `CREATE'.
  261. `LIST'
  262.      Display full contents of the current archive, in "verbose" style
  263.      regardless of the state of `VERBOSE'.  The effect is like `ar tv
  264.      ARCHIVE').  (This single command is a GNU `ld' enhancement, rather
  265.      than present for MRI compatibility.)
  266.      Requires prior use of `OPEN' or `CREATE'.
  267. `OPEN ARCHIVE'
  268.      Opens an existing archive for use as the current archive (required
  269.      for many other commands).  Any changes as the result of subsequent
  270.      commands will not actually affect ARCHIVE until you next use
  271.      `SAVE'.
  272. `REPLACE MODULE, MODULE, ... MODULE'
  273.      In the current archive, replace each existing MODULE (named in the
  274.      `REPLACE' arguments) from files in the current working directory.
  275.      To execute this command without errors, both the file, and the
  276.      module in the current archive, must exist.
  277.      Requires prior use of `OPEN' or `CREATE'.
  278. `VERBOSE'
  279.      Toggle an internal flag governing the output from `DIRECTORY'.
  280.      When the flag is on, `DIRECTORY' output matches output from `ar
  281.      -tv '....
  282. `SAVE'
  283.      Commit your changes to the current archive, and actually save it
  284.      as a file with the name specified in the last `CREATE' or `OPEN'
  285.      command.
  286.      Requires prior use of `OPEN' or `CREATE'.
  287. File: binutils.info,  Node: nm,  Next: objcopy,  Prev: ar,  Up: Top
  288.      nm [ -a | --debug-syms ]  [ -g | --extern-only ]
  289.         [ -B ]  [ -C | --demangle ] [ -D | --dynamic ]
  290.         [ -s | --print-armap ]  [ -A | -o | --print-file-name ]
  291.         [ -n | -v | --numeric-sort ]  [ -p | --no-sort ]
  292.         [ -r | --reverse-sort ]  [ --size-sort ] [ -u | --undefined-only ]
  293.         [ -t RADIX | --radix=RADIX ] [ -P | --portability ]
  294.         [ --target=BFDNAME ] [ -f FORMAT | --format=FORMAT ]
  295.         [ --no-demangle ] [ -V | --version ]  [ --help ]  [ OBJFILE... ]
  296.    GNU `nm' lists the symbols from object files OBJFILE....  If no
  297. object files are listed as arguments, `nm' assumes `a.out'.
  298.    For each symbol, `nm' shows:
  299.    * The symbol value, in the radix selected by options (see below), or
  300.      hexadecimal by default.
  301.    * The symbol type.  At least the following types are used; others
  302.      are, as well, depending on the object file format.  If lowercase,
  303.      the symbol is local; if uppercase, the symbol is global (external).
  304.     `A'
  305.           Absolute.
  306.     `B'
  307.           BSS (uninitialized data).
  308.     `C'
  309.           Common.
  310.     `D'
  311.           Initialized data.
  312.     `I'
  313.           Indirect reference.
  314.     `T'
  315.           Text (program code).
  316.     `U'
  317.           Undefined.
  318.    * The symbol name.
  319.    The long and short forms of options, shown here as alternatives, are
  320. equivalent.
  321. `--print-file-name'
  322.      Precede each symbol by the name of the input file (or archive
  323.      element) in which it was found, rather than identifying the input
  324.      file once only, before all of its symbols.
  325. `--debug-syms'
  326.      Display all symbols, even debugger-only symbols; normally these
  327.      are not listed.
  328.      The same as `--format=bsd' (for compatibility with the MIPS `nm').
  329. `--demangle'
  330.      Decode ("demangle") low-level symbol names into user-level names.
  331.      Besides removing any initial underscore prepended by the system,
  332.      this makes C++ function names readable.  *Note c++filt::, for more
  333.      information on demangling.
  334. `--no-demangle'
  335.      Do not demangle low-level symbol names.  This is the default.
  336. `--dynamic'
  337.      Display the dynamic symbols rather than the normal symbols.  This
  338.      is only meaningful for dynamic objects, such as certain types of
  339.      shared libraries.
  340. `-f FORMAT'
  341. `--format=FORMAT'
  342.      Use the output format FORMAT, which can be `bsd', `sysv', or
  343.      `posix'.  The default is `bsd'.  Only the first character of
  344.      FORMAT is significant; it can be either upper or lower case.
  345. `--extern-only'
  346.      Display only external symbols.
  347. `--numeric-sort'
  348.      Sort symbols numerically by their addresses, rather than
  349.      alphabetically by their names.
  350. `--no-sort'
  351.      Do not bother to sort the symbols in any order; print them in the
  352.      order encountered.
  353. `--portability'
  354.      Use the POSIX.2 standard output format instead of the default
  355.      format.  Equivalent to `-f posix'.
  356. `--print-armap'
  357.      When listing symbols from archive members, include the index: a
  358.      mapping (stored in the archive by `ar' or `ranlib') of which
  359.      modules contain definitions for which names.
  360. `--reverse-sort'
  361.      Reverse the order of the sort (whether numeric or alphabetic); let
  362.      the last come first.
  363. `--size-sort'
  364.      Sort symbols by size.  The size is computed as the difference
  365.      between the value of the symbol and the value of the symbol with
  366.      the next higher value.  The size of the symbol is printed, rather
  367.      than the value.
  368. `-t RADIX'
  369. `--radix=RADIX'
  370.      Use RADIX as the radix for printing the symbol values.  It must be
  371.      `d' for decimal, `o' for octal, or `x' for hexadecimal.
  372. `--target=BFDNAME'
  373.      Specify an object code format other than your system's default
  374.      format.  *Note Target Selection::, for more information.
  375. `--undefined-only'
  376.      Display only undefined symbols (those external to each object
  377.      file).
  378. `--version'
  379.      Show the version number of `nm' and exit.
  380. `--help'
  381.      Show a summary of the options to `nm' and exit.
  382. File: binutils.info,  Node: objcopy,  Next: objdump,  Prev: nm,  Up: Top
  383. objcopy
  384. *******
  385.      objcopy [ -F BFDNAME | --target=BFDNAME ]
  386.              [ -I BFDNAME | --input-target=BFDNAME ]
  387.              [ -O BFDNAME | --output-target=BFDNAME ]
  388.              [ -S | --strip-all ]  [ -g | --strip-debug ]
  389.              [ -x | --discard-all ]  [ -X | --discard-locals ]
  390.              [ -b BYTE | --byte=BYTE ]
  391.              [ -i INTERLEAVE | --interleave=INTERLEAVE ]
  392.              [ -R SECTIONNAME | --remove-section=SECTIONNAME ]
  393.              [ -v | --verbose ] [ -V | --version ]  [ --help ]
  394.              INFILE [OUTFILE]
  395.    The GNU `objcopy' utility copies the contents of an object file to
  396. another.  `objcopy' uses the GNU BFD Library to read and write the
  397. object files.  It can write the destination object file in a format
  398. different from that of the source object file.  The exact behavior of
  399. `objcopy' is controlled by command-line options.
  400.    `objcopy' creates temporary files to do its translations and deletes
  401. them afterward.  `objcopy' uses BFD to do all its translation work; it
  402. has access to all the formats described in BFD and thus is able to
  403. recognize most formats without being told explicitly.  *Note BFD:
  404. (ld.info)BFD.
  405. `INFILE'
  406. `OUTFILE'
  407.      The source and output files, respectively.  If you do not specify
  408.      OUTFILE, `objcopy' creates a temporary file and destructively
  409.      renames the result with the name of INFILE.
  410. `-I BFDNAME'
  411. `--input-target=BFDNAME'
  412.      Consider the source file's object format to be BFDNAME, rather than
  413.      attempting to deduce it.  *Note Target Selection::, for more
  414.      information.
  415. `-O BFDNAME'
  416. `--output-target=BFDNAME'
  417.      Write the output file using the object format BFDNAME.  *Note
  418.      Target Selection::, for more information.
  419. `-F BFDNAME'
  420. `--target=BFDNAME'
  421.      Use BFDNAME as the object format for both the input and the output
  422.      file; i.e., simply transfer data from source to destination with no
  423.      translation.  *Note Target Selection::, for more information.
  424. `-R SECTIONNAME'
  425. `--remove-section=SECTIONNAME'
  426.      Remove any section named SECTIONNAME from the output file.  This
  427.      option may be given more than once.  Note that using this option
  428.      inappropriately may make the output file unusable.
  429. `--strip-all'
  430.      Do not copy relocation and symbol information from the source file.
  431. `--strip-debug'
  432.      Do not copy debugging symbols from the source file.
  433. `--discard-all'
  434.      Do not copy non-global symbols from the source file.
  435. `--discard-locals'
  436.      Do not copy compiler-generated local symbols.  (These usually
  437.      start with `L' or `.'.)
  438. `-b BYTE'
  439. `--byte=BYTE'
  440.      Keep only every BYTEth byte of the input file (header data is not
  441.      affected).  BYTE can be in the range from 0 to INTERLEAVE-1, where
  442.      INTERLEAVE is given by the `-i' or `--interleave' option, or the
  443.      default of 4.  This option is useful for creating files to program
  444.      ROM.  It is typically used with an `srec' output target.
  445. `-i INTERLEAVE'
  446. `--interleave=INTERLEAVE'
  447.      Only copy one out of every INTERLEAVE bytes.  Select which byte to
  448.      copy with the -B or `--byte' option.  The default is 4.  `objcopy'
  449.      ignores this option if you do not specify either `-b' or `--byte'.
  450. `--version'
  451.      Show the version number of `objcopy'.
  452. `--verbose'
  453.      Verbose output: list all object files modified.  In the case of
  454.      archives, `objcopy -V' lists all members of the archive.
  455. `--help'
  456.      Show a summary of the options to `objcopy'.
  457. File: binutils.info,  Node: objdump,  Next: ranlib,  Prev: objcopy,  Up: Top
  458. objdump
  459. *******
  460.      objdump [ -a | --archive-headers ]
  461.              [ -b BFDNAME | --target=BFDNAME ]
  462.              [ -d | --disassemble ]  [ -D | --disassemble-all ]
  463.              [ -f | --file-headers ]
  464.              [ -h | --section-headers | --headers ]  [ -i | --info ]
  465.              [ -j SECTION | --section=SECTION ]
  466.              [ -l | --line-numbers ]
  467.              [ -m MACHINE | --architecture=MACHINE ]
  468.              [ -r | --reloc ] [ -R | --dynamic-reloc ]
  469.              [ -s | --full-contents ]  [ --stabs ]
  470.              [ -t | --syms ] [ -T | --dynamic-syms ] [ -x | --all-headers ]
  471.              [ --version ]  [ --help ] OBJFILE...
  472.    `objdump' displays information about one or more object files.  The
  473. options control what particular information to display.  This
  474. information is mostly useful to programmers who are working on the
  475. compilation tools, as opposed to programmers who just want their
  476. program to compile and work.
  477.    OBJFILE... are the object files to be examined.  When you specify
  478. archives, `objdump' shows information on each of the member object
  479. files.
  480.    The long and short forms of options, shown here as alternatives, are
  481. equivalent.  At least one option besides `-l' must be given.
  482. `--archive-header'
  483.      If any of the OBJFILE files are archives, display the archive
  484.      header information (in a format similar to `ls -l').  Besides the
  485.      information you could list with `ar tv', `objdump -a' shows the
  486.      object file format of each archive member.
  487. `-b BFDNAME'
  488. `--target=BFDNAME'
  489.      Specify that the object-code format for the object files is
  490.      BFDNAME.  This option may not be necessary; OBJDUMP can
  491.      automatically recognize many formats.
  492.      For example,
  493.           objdump -b oasys -m vax -h fu.o
  494.      displays summary information from the section headers (`-h') of
  495.      `fu.o', which is explicitly identified (`-m') as a VAX object file
  496.      in the format produced by Oasys compilers.  You can list the
  497.      formats available with the `-i' option.  *Note Target Selection::,
  498.      for more information.
  499. `--disassemble'
  500.      Display the assembler mnemonics for the machine instructions from
  501.      OBJFILE.  This option only disassembles those sections which are
  502.      expected to contain instructions.
  503. `--disassemble-all'
  504.      Like `-d', but disassemble the contents of all sections, not just
  505.      those expected to contain instructions.
  506. `--file-header'
  507.      Display summary information from the overall header of each of the
  508.      OBJFILE files.
  509. `--section-header'
  510. `--header'
  511.      Display summary information from the section headers of the object
  512.      file.
  513.      File segments may be relocated to nonstandard addresses, for
  514.      example by using the `-Ttext', `-Tdata', or `-Tbss' options to
  515.      `ld'.  However, some object file formats, such as a.out, do not
  516.      store the starting address of the file segments.  In those
  517.      situations, although `ld' relocates the sections correctly, using
  518.      `objdump -h' to list the file section headers cannot show the
  519.      correct addresses.  Instead, it shows the usual addresses, which
  520.      are implicit for the target.
  521. `--help'
  522.      Print a summary of the options to `objdump' and exit.
  523. `--info'
  524.      Display a list showing all architectures and object formats
  525.      available for specification with `-b' or `-m'.
  526. `-j NAME'
  527. `--section=NAME'
  528.      Display information only for section NAME.
  529. `--line-numbers'
  530.      Label the display (using debugging information) with the filename
  531.      and source line numbers corresponding to the object code shown.
  532.      Only useful with `-d' or `-D'.
  533. `-m MACHINE'
  534. `--architecture=MACHINE'
  535.      Specify that the object files OBJFILE are for architecture
  536.      MACHINE.  You can list available architectures using the `-i'
  537.      option.
  538. `--reloc'
  539.      Print the relocation entries of the file.  If used with `-d' or
  540.      `-D', the relocations are printed interspersed with the
  541.      disassembly.
  542. `--dynamic-reloc'
  543.      Print the dynamic relocation entries of the file.  This is only
  544.      meaningful for dynamic objects, such as certain types of shared
  545.      libraries.
  546. `--full-contents'
  547.      Display the full contents of any sections requested.
  548. `--stabs'
  549.      Display the full contents of any sections requested.  Display the
  550.      contents of the .stab and .stab.index and .stab.excl sections from
  551.      an ELF file.  This is only useful on systems (such as Solaris 2.0)
  552.      in which `.stab' debugging symbol-table entries are carried in an
  553.      ELF section.  In most other file formats, debugging symbol-table
  554.      entries are interleaved with linkage symbols, and are visible in
  555.      the `--syms' output.
  556. `--syms'
  557.      Print the symbol table entries of the file.  This is similar to
  558.      the information provided by the `nm' program.
  559. `--dynamic-syms'
  560.      Print the dynamic symbol table entries of the file.  This is only
  561.      meaningful for dynamic objects, such as certain types of shared
  562.      libraries.  This is similar to the information provided by the `nm'
  563.      program when given the `-D' (`--dynamic') option.
  564. `--version'
  565.      Print the version number of `objdump' and exit.
  566. `--all-header'
  567.      Display all available header information, including the symbol
  568.      table and relocation entries.  Using `-x' is equivalent to
  569.      specifying all of `-a -f -h -r -t'.
  570. File: binutils.info,  Node: ranlib,  Next: size,  Prev: objdump,  Up: Top
  571. ranlib
  572. ******
  573.      ranlib [-vV] ARCHIVE
  574.    `ranlib' generates an index to the contents of an archive and stores
  575. it in the archive.  The index lists each symbol defined by a member of
  576. an archive that is a relocatable object file.
  577.    You may use `nm -s' or `nm --print-armap' to list this index.
  578.    An archive with such an index speeds up linking to the library and
  579. allows routines in the library to call each other without regard to
  580. their placement in the archive.
  581.    The GNU `ranlib' program is another form of GNU `ar'; running
  582. `ranlib' is completely equivalent to executing `ar -s'.  *Note ar::.
  583.      Show the version number of `ranlib'.
  584. File: binutils.info,  Node: size,  Next: strings,  Prev: ranlib,  Up: Top
  585.      size [ -A | -B | --format=COMPATIBILITY ]
  586.           [ --help ]  [ -d | -o | -x | --radix=NUMBER ]
  587.           [ --target=BFDNAME ]  [ -V | --version ]
  588.           OBJFILE...
  589.    The GNU `size' utility lists the section sizes--and the total
  590. size--for each of the object or archive files OBJFILE in its argument
  591. list.  By default, one line of output is generated for each object file
  592. or each module in an archive.
  593.    OBJFILE... are the object files to be examined.
  594.    The command line options have the following meanings:
  595. `--format=COMPATIBILITY'
  596.      Using one of these options, you can choose whether the output from
  597.      GNU `size' resembles output from System V `size' (using `-A', or
  598.      `--format=sysv'), or Berkeley `size' (using `-B', or
  599.      `--format=berkeley').  The default is the one-line format similar
  600.      to Berkeley's.
  601.      Here is an example of the Berkeley (default) format of output from
  602.      `size':
  603.           size --format=Berkeley ranlib size
  604.           text    data    bss     dec     hex     filename
  605.           294880  81920   11592   388392  5ed28   ranlib
  606.           294880  81920   11888   388688  5ee50   size
  607.      This is the same data, but displayed closer to System V
  608.      conventions:
  609.           size --format=SysV ranlib size
  610.           ranlib  :
  611.           section         size         addr
  612.           .text         294880         8192
  613.           .data          81920       303104
  614.           .bss           11592       385024
  615.           Total         388392
  616.           
  617.           
  618.           size  :
  619.           section         size         addr
  620.           .text         294880         8192
  621.           .data          81920       303104
  622.           .bss           11888       385024
  623.           Total         388688
  624. `--help'
  625.      Show a summary of acceptable arguments and options.
  626. `--radix=NUMBER'
  627.      Using one of these options, you can control whether the size of
  628.      each section is given in decimal (`-d', or `--radix=10'); octal
  629.      (`-o', or `--radix=8'); or hexadecimal (`-x', or `--radix=16').
  630.      In `--radix=NUMBER', only the three values (8, 10, 16) are
  631.      supported.  The total size is always given in two radices; decimal
  632.      and hexadecimal for `-d' or `-x' output, or octal and hexadecimal
  633.      if you're using `-o'.
  634. `--target=BFDNAME'
  635.      Specify that the object-code format for OBJFILE is BFDNAME.  This
  636.      option may not be necessary; `size' can automatically recognize
  637.      many formats.  *Note Target Selection::, for more information.
  638. `--version'
  639.      Display the version number of `size'.
  640. File: binutils.info,  Node: strings,  Next: strip,  Prev: size,  Up: Top
  641. strings
  642. *******
  643.      strings [-afov] [-MIN-LEN] [-n MIN-LEN] [-t RADIX] [-]
  644.              [--all] [--print-file-name] [--bytes=MIN-LEN]
  645.              [--radix=RADIX] [--target=BFDNAME]
  646.              [--help] [--version] FILE...
  647.    For each FILE given, GNU `strings' prints the printable character
  648. sequences that are at least 4 characters long (or the number given with
  649. the options below) and are followed by a NUL or newline character.  By
  650. default, it only prints the strings from the initialized data sections
  651. of object files; for other types of files, it prints the strings from
  652. the whole file.
  653.    `strings' is mainly useful for determining the contents of non-text
  654. files.
  655. `--all'
  656.      Do not scan only the initialized data section of object files; scan
  657.      the whole files.
  658. `--print-file-name'
  659.      Print the name of the file before each string.
  660. `--help'
  661.      Print a summary of the program usage on the standard output and
  662.      exit.
  663. `-MIN-LEN'
  664. `-n MIN-LEN'
  665. `--bytes=MIN-LEN'
  666.      Print sequences of characters that are at least MIN-LEN characters
  667.      long, instead of the default 4.
  668.      Like `-t o'.  Some other versions of `strings' have `-o' act like
  669.      `-t d' instead.  Since we can not be compatible with both ways, we
  670.      simply chose one.
  671. `-t RADIX'
  672. `--radix=RADIX'
  673.      Print the offset within the file before each string.  The single
  674.      character argument specifies the radix of the offset--`o' for
  675.      octal, `x' for hexadecimal, or `d' for decimal.
  676. `--target=BFDNAME'
  677.      Specify an object code format other than your system's default
  678.      format.  *Note Target Selection::, for more information.
  679. `--version'
  680.      Print the program version number on the standard output and exit.
  681. File: binutils.info,  Node: strip,  Next: c++filt,  Prev: strings,  Up: Top
  682. strip
  683. *****
  684.      strip [ -F BFDNAME | --target=BFDNAME | --target=BFDNAME ]
  685.            [ -I BFDNAME | --input-target=BFDNAME ]
  686.            [ -O BFDNAME | --output-target=BFDNAME ]
  687.            [ -s | --strip-all ] [ -S | -g | --strip-debug ]
  688.            [ -x | --discard-all ] [ -X | --discard-locals ]
  689.            [ -R SECTIONNAME | --remove-section=SECTIONNAME ]
  690.            [ -v | --verbose ]  [ -V | --version ]  [ --help ]
  691.            OBJFILE...
  692.    GNU `strip' discards all symbols from object files OBJFILE.  The
  693. list of object files may include archives.  At least one object file
  694. must be given.
  695.    `strip' modifies the files named in its argument, rather than
  696. writing modified copies under different names.
  697. `-F BFDNAME'
  698. `--target=BFDNAME'
  699.      Treat the original OBJFILE as a file with the object code format
  700.      BFDNAME, and rewrite it in the same format.  *Note Target
  701.      Selection::, for more information.
  702. `--help'
  703.      Show a summary of the options to `strip' and exit.
  704. `-I BFDNAME'
  705. `--input-target=BFDNAME'
  706.      Treat the original OBJFILE as a file with the object code format
  707.      BFDNAME.  *Note Target Selection::, for more information.
  708. `-O BFDNAME'
  709. `--output-target=BFDNAME'
  710.      Replace OBJFILE with a file in the output format BFDNAME.  *Note
  711.      Target Selection::, for more information.
  712. `-R SECTIONNAME'
  713. `--remove-section=SECTIONNAME'
  714.      Remove any section named SECTIONNAME from the output file.  This
  715.      option may be given more than once.  Note that using this option
  716.      inappropriately may make the output file unusable.
  717. `--strip-all'
  718.      Remove all symbols.
  719. `--strip-debug'
  720.      Remove debugging symbols only.
  721. `--discard-all'
  722.      Remove non-global symbols.
  723. `--discard-locals'
  724.      Remove compiler-generated local symbols.  (These usually start
  725.      with `L' or `.'.)
  726. `--version'
  727.      Show the version number for `strip'.
  728. `--verbose'
  729.      Verbose output: list all object files modified.  In the case of
  730.      archives, `strip -v' lists all members of the archive.
  731. File: binutils.info,  Node: c++filt,  Next: nlmconv,  Prev: strip,  Up: Top
  732. c++filt
  733. *******
  734.      c++filt [ -_ | --strip-underscores ]
  735.          [ -n | --no-strip-underscores ]
  736.              [ -s FORMAT | --format=FORMAT ]
  737.              [ --help ]  [ --version ]  [ SYMBOL... ]
  738.    The C++ language provides function overloading, which means that you
  739. can write many functions with the same name (providing each takes
  740. parameters of different types).  All C++ function names are encoded
  741. into a low-level assembly label (this process is known as "mangling").
  742. The `c++filt' program does the inverse mapping: it decodes
  743. ("demangles") low-level names into user-level names so that the linker
  744. can keep these overloaded functions from clashing.
  745.    Every alphanumeric word (consisting of letters, digits, underscores,
  746. dollars, or periods) seen in the input is a potential label.  If the
  747. label decodes into a C++ name, the C++ name replaces the low-level name
  748. in the output.
  749.    You can use `c++filt' to decipher individual symbols:
  750.      c++filt SYMBOL
  751.    If no SYMBOL arguments are given, `c++filt' reads symbol names from
  752. the standard input and writes the demangled names to the standard
  753. output.  All results are printed on the standard output.
  754. `--strip-underscores'
  755.      On some systems, both the C and C++ compilers put an underscore in
  756.      front of every name.  For example, the C name `foo' gets the
  757.      low-level name `_foo'.  This option removes the initial
  758.      underscore.  Whether `c++filt' removes the underscore by default
  759.      is target dependent.
  760. `--no-strip-underscores'
  761.      Do not remove the initial underscore.
  762. `-s FORMAT'
  763. `--format=FORMAT'
  764.      GNU `nm' can decode three different methods of mangling, used by
  765.      different C++ compilers.  The argument to this option selects which
  766.      method it uses:
  767.     `gnu'
  768.           the one used by the GNU compiler (the default method)
  769.     `lucid'
  770.           the one used by the Lucid compiler
  771.     `arm'
  772.           the one specified by the C++ Annotated Reference Manual
  773. `--help'
  774.      Print a summary of the options to `c++filt' and exit.
  775. `--version'
  776.      Print the version number of `c++filt' and exit.
  777.      *Warning:* `c++filt' is a new utility, and the details of its user
  778.      interface are subject to change in future releases.  In particular,
  779.      a command-line option may be required in the the future to decode
  780.      a name passed as an argument on the command line; in other words,
  781.           c++filt SYMBOL
  782.      may in a future release become
  783.           c++filt OPTION SYMBOL
  784. File: binutils.info,  Node: nlmconv,  Next: Selecting The Target System,  Prev: c++filt,  Up: Top
  785. nlmconv
  786. *******
  787.    `nlmconv' converts a relocatable object file into a NetWare Loadable
  788. Module.
  789.      *Warning:* `nlmconv' is not always built as part of the binary
  790.      utilities, since it is only useful for NLM targets.
  791.      nlmconv [ -I BFDNAME | --input-target=BFDNAME ]
  792.              [ -O BFDNAME | --output-target=BFDNAME ]
  793.              [ -T HEADERFILE | --header-file=HEADERFILE ]
  794.              [ -d | --debug]  [ -l LINKER | --linker=LINKER ]
  795.              [ -h | --help ]  [ -V | --version ]
  796.              INFILE OUTFILE
  797.    `nlmconv' converts the relocatable `i386' object file INFILE into
  798. the NetWare Loadable Module OUTFILE, optionally reading HEADERFILE for
  799. NLM header information.  For instructions on writing the NLM command
  800. file language used in header files, see the `linkers' section,
  801. `NLMLINK' in particular, of the `NLM Development and Tools Overview',
  802. which is part of the NLM Software Developer's Kit ("NLM SDK"),
  803. available from Novell, Inc.  `nlmconv' uses the GNU Binary File
  804. Descriptor library to read INFILE; see *Note BFD: (ld.info)BFD, for
  805. more information.
  806.    `nlmconv' can perform a link step.  In other words, you can list
  807. more than one object file for input if you list them in the definitions
  808. file (rather than simply specifying one input file on the command line).
  809. In this case, `nlmconv' calls the linker for you.
  810. `-I BFDNAME'
  811. `--input-target=BFDNAME'
  812.      Object format of the input file.  `nlmconv' can usually determine
  813.      the format of a given file (so no default is necessary).  *Note
  814.      Target Selection::, for more information.
  815. `-O BFDNAME'
  816. `--output-target=BFDNAME'
  817.      Object format of the output file.  `nlmconv' infers the output
  818.      format based on the input format, e.g. for a `i386' input file the
  819.      output format is `nlm32-i386'.  *Note Target Selection::, for more
  820.      information.
  821. `-T HEADERFILE'
  822. `--header-file=HEADERFILE'
  823.      Reads HEADERFILE for NLM header information.  For instructions on
  824.      writing the NLM command file language used in header files, see
  825.      see the `linkers' section, of the `NLM Development and Tools
  826.      Overview', which is part of the NLM Software Developer's Kit,
  827.      available from Novell, Inc.
  828. `--debug'
  829.      Displays (on standard error) the linker command line used by
  830.      `nlmconv'.
  831. `-l LINKER'
  832. `--linker=LINKER'
  833.      Use LINKER for any linking.  LINKER can be an abosolute or a
  834.      relative pathname.
  835. `--help'
  836.      Prints a usage summary.
  837. `--version'
  838.      Prints the version number for `nlmconv'.
  839. File: binutils.info,  Node: Selecting The Target System,  Next: Index,  Prev: nlmconv,  Up: Top
  840. Selecting the target system
  841. ***************************
  842.    You can specify three aspects of the target system to the GNU binary
  843. file utilities, each in several ways:
  844.    * the target
  845.    * the architecture
  846.    * the linker emulation (which applies to the linker only)
  847.    In the following summaries, the lists of ways to specify values are
  848. in order of decreasing precedence.  The ways listed first override those
  849. listed later.
  850.    The commands to list valid values only list the values for which the
  851. programs you are running were configured.  If they were configured with
  852. `--with-targets=all', the commands list most of the available values,
  853. but a few are left out; not all targets can be configured in at once
  854. because some of them can only be configured "native" (on hosts with the
  855. same type as the target system).
  856. * Menu:
  857. * Target Selection::
  858. * Architecture Selection::
  859. * Linker Emulation Selection::
  860. File: binutils.info,  Node: Target Selection,  Next: Architecture Selection,  Up: Selecting The Target System
  861. Target Selection
  862. ================
  863.    A "target" is an object file format.  A given target may be
  864. supported for multiple architectures (*note Architecture Selection::.).
  865. A target selection may also have variations for different operating
  866. systems or architectures.
  867.    The command to list valid target values is `objdump -i' (the first
  868. column of output contains the relevant information).
  869.    Some sample values are: `a.out-hp300bsd', `ecoff-littlemips',
  870. `a.out-sunos-big'.
  871. `objdump' Target
  872. ----------------
  873.    Ways to specify:
  874.   1. command line option: `-b' or `--target'
  875.   2. environment variable `GNUTARGET'
  876.   3. deduced from the input file
  877. `objcopy' and `strip' Input Target
  878. ----------------------------------
  879.    Ways to specify:
  880.   1. command line options: `-I' or `--input-target', or `-F' or
  881.      `--target'
  882.   2. environment variable `GNUTARGET'
  883.   3. deduced from the input file
  884. `objcopy' and `strip' Output Target
  885. -----------------------------------
  886.    Ways to specify:
  887.   1. command line options: `-O' or `--output-target', or `-F' or
  888.      `--target'
  889.   2. the input target (see "`objcopy' and `strip' Input Target" above)
  890.   3. environment variable `GNUTARGET'
  891.   4. deduced from the input file
  892. `nm', `size', and `strings' Target
  893. ----------------------------------
  894.    Ways to specify:
  895.   1. command line option: `--target'
  896.   2. environment variable `GNUTARGET'
  897.   3. deduced from the input file
  898. Linker Input Target
  899. -------------------
  900.    Ways to specify:
  901.   1. command line option: `-b' or `--format' (*note Options:
  902.      (ld.info)Options.)
  903.   2. script command `TARGET' (*note Option Commands: (ld.info)Option
  904.      Commands.)
  905.   3. environment variable `GNUTARGET' (*note Environment:
  906.      (ld.info)Environment.)
  907.   4. the default target of the selected linker emulation (*note Linker
  908.      Emulation Selection::.)
  909. Linker Output Target
  910. --------------------
  911.    Ways to specify:
  912.   1. command line option: `-oformat' (*note Options: (ld.info)Options.)
  913.   2. script command `OUTPUT_FORMAT' (*note Option Commands:
  914.      (ld.info)Option Commands.)
  915.   3. the linker input target (see "Linker Input Target" above)
  916. File: binutils.info,  Node: Architecture Selection,  Next: Linker Emulation Selection,  Prev: Target Selection,  Up: Selecting The Target System
  917. Architecture selection
  918. ======================
  919.    An "architecture" is a type of CPU on which an object file is to
  920. run.  Its name may contain a colon, separating the name of the
  921. processor family from the name of the particular CPU.
  922.    The command to list valid architecture values is `objdump -i' (the
  923. second column contains the relevant information).
  924.    Sample values: `m68k:68020', `mips:3000', `sparc'.
  925. `objdump' Architecture
  926. ----------------------
  927.    Ways to specify:
  928.   1. command line option: `-m' or `--architecture'
  929.   2. deduced from the input file
  930. `objcopy', `nm', `size', `strings' Architecture
  931. -----------------------------------------------
  932.    Ways to specify:
  933.   1. deduced from the input file
  934. Linker Input Architecture
  935. -------------------------
  936.    Ways to specify:
  937.   1. deduced from the input file
  938. Linker Output Architecture
  939. --------------------------
  940.    Ways to specify:
  941.   1. script command `OUTPUT_ARCH' (*note Option Commands:
  942.      (ld.info)Option Commands.)
  943.   2. the default architecture from the linker output target (*note
  944.      Target Selection::.)
  945. File: binutils.info,  Node: Linker Emulation Selection,  Prev: Architecture Selection,  Up: Selecting The Target System
  946. Linker emulation selection
  947. ==========================
  948.    A linker "emulation" is a "personality" of the linker, which gives
  949. the linker default values for the other aspects of the target system.
  950. In particular, it consists of
  951.    * the linker script
  952.    * the target
  953.    * several "hook" functions that are run at certain stages of the
  954.      linking process to do special things that some targets require
  955.    The command to list valid linker emulation values is `ld -V'.
  956.    Sample values: `hp300bsd', `mipslit', `sun4'.
  957.    Ways to specify:
  958.   1. command line option: `-m' (*note Options: (ld.info)Options.)
  959.   2. environment variable `LDEMULATION'
  960.   3. compiled-in `DEFAULT_EMULATION' from `Makefile', which comes from
  961.      `EMUL' in `config/TARGET.mt'
  962. File: binutils.info,  Node: Index,  Prev: Selecting The Target System,  Up: Top
  963. Index
  964. *****
  965. * Menu:
  966. * .stab:                                objdump.
  967. * ar compatibility:                     ar.
  968. * nm compatibility:                     nm.
  969. * nm compatibility:                     nm.
  970. * nm format:                            nm.
  971. * nm format:                            nm.
  972. * size display format:                  size.
  973. * size number format:                   size.
  974. * all header information, object file:  objdump.
  975. * ar:                                   ar.
  976. * architecture:                         objdump.
  977. * architectures available:              objdump.
  978. * archive contents:                     ranlib.
  979. * archive headers:                      objdump.
  980. * archives:                             ar.
  981. * c++filt:                              c++filt.
  982. * collections of files:                 ar.
  983. * compatibility, ar:                    ar.
  984. * contents of archive:                  ar cmdline.
  985. * creating archives:                    ar cmdline.
  986. * dates in archive:                     ar cmdline.
  987. * debug symbols:                        objdump.
  988. * debugging symbols:                    nm.
  989. * deleting from archive:                ar cmdline.
  990. * demangling C++ symbols:               c++filt.
  991. * demangling C++ symbols:               nm.
  992. * disassembling object code:            objdump.
  993. * discarding symbols:                   strip.
  994. * dynamic relocation entries, in object file: objdump.
  995. * dynamic symbol table entries, printing: objdump.
  996. * dynamic symbols:                      nm.
  997. * ELF object file format:               objdump.
  998. * external symbols:                     nm.
  999. * external symbols:                     nm.
  1000. * extract from archive:                 ar cmdline.
  1001. * file name:                            nm.
  1002. * header information, all:              objdump.
  1003. * input file name:                      nm.
  1004. * libraries:                            ar.
  1005. * listings strings:                     strings.
  1006. * machine instructions:                 objdump.
  1007. * moving in archive:                    ar cmdline.
  1008. * MRI compatibility, ar:                ar scripts.
  1009. * name duplication in archive:          ar cmdline.
  1010. * name length:                          ar.
  1011. * nm:                                   nm.
  1012. * objdump:                              objdump.
  1013. * object code format:                   objdump.
  1014. * object code format:                   size.
  1015. * object code format:                   nm.
  1016. * object code format:                   strings.
  1017. * object file header:                   objdump.
  1018. * object file information:              objdump.
  1019. * object file sections:                 objdump.
  1020. * object formats available:             objdump.
  1021. * operations on archive:                ar cmdline.
  1022. * printing from archive:                ar cmdline.
  1023. * printing strings:                     strings.
  1024. * quick append to archive:              ar cmdline.
  1025. * radix for section sizes:              size.
  1026. * ranlib:                               ranlib.
  1027. * relative placement in archive:        ar cmdline.
  1028. * relocation entries, in object file:   objdump.
  1029. * removing symbols:                     strip.
  1030. * repeated names in archive:            ar cmdline.
  1031. * replacement in archive:               ar cmdline.
  1032. * scripts, ar:                          ar scripts.
  1033. * section headers:                      objdump.
  1034. * section information:                  objdump.
  1035. * section sizes:                        size.
  1036. * sections, full contents:              objdump.
  1037. * size:                                 size.
  1038. * sorting symbols:                      nm.
  1039. * source file name:                     nm.
  1040. * source filenames for object files:    objdump.
  1041. * stab:                                 objdump.
  1042. * strings:                              strings.
  1043. * strings, printing:                    strings.
  1044. * strip:                                strip.
  1045. * symbol index:                         ranlib.
  1046. * symbol index:                         ar.
  1047. * symbol index, listing:                nm.
  1048. * symbol table entries, printing:       objdump.
  1049. * symbols:                              nm.
  1050. * symbols, discarding:                  strip.
  1051. * undefined symbols:                    nm.
  1052. * Unix compatibility, ar:               ar cmdline.
  1053. * updating an archive:                  ar cmdline.
  1054. * version:                              Top.
  1055. * writing archive index:                ar cmdline.
  1056. Tag Table:
  1057. Node: Top
  1058. Node: ar
  1059. Node: ar cmdline
  1060. Node: ar scripts
  1061. 10476
  1062. Node: nm
  1063. 16157
  1064. Node: objcopy
  1065. 20273
  1066. Node: objdump
  1067. 23830
  1068. Node: ranlib
  1069. 29297
  1070. Node: size
  1071. 30031
  1072. Node: strings
  1073. 32698
  1074. Node: strip
  1075. 34512
  1076. Node: c++filt
  1077. 36634
  1078. Node: nlmconv
  1079. 39193
  1080. Node: Selecting The Target System
  1081. 41816
  1082. Node: Target Selection
  1083. 42822
  1084. Node: Architecture Selection
  1085. 45070
  1086. Node: Linker Emulation Selection
  1087. 46302
  1088. Node: Index
  1089. 47180
  1090. End Tag Table
  1091.